<?php


class GD_Helper {

	// if $bgcolor is empty, transparent is used
	function new_canvas($width, $height, $bgcolor = 'FFFFFF') {
		if(!($im = imagecreatetruecolor($width, $height))) {
			return false;
		}
		if(empty($bgcolor)) {
			imagesavealpha($im, true);
			$color = imagecolorallocatealpha($im, 0, 0, 0, 127);
		} elseif(is_string($bgcolor)) {
			list($r, $g, $b) = self::str2rgb($bgcolor);
			$color = imagecolorallocate($im, $r, $g, $b);
		} else {
			$color = $bgcolor;
		}
		imagefill($im, 0, 0, $color);
		return $im;
	}
	
	function str2rgb($str) {
		$r = 0; $g = 0; $b = 0;
		if(strlen($str) == 3) {
			$str = ($str{0}.$str{0}) . ($str{1}.$str{1}) . ($str{2}.$str{2});
		}
		if(strlen($str) == 6) {
			$r = hexdec(substr($str, 0, 2));
			$g = hexdec(substr($str, 2, 2));
			$b = hexdec(substr($str, 4, 2));
		}
		return array($r, $g, $b);
    }

	// Author: Tim Eckel - Date: 12/17/04 - Project: FreeRingers.net - Freely distributable.
	// Optional "quality" parameter (defaults is 3).  Fractional values are allowed, for example 1.5.
	// 1 = Up to 600 times faster.  Poor results, just uses imagecopyresized but removes black edges.
	// 2 = Up to 95 times faster.  Images may appear too sharp, some people may prefer it.
	// 3 = Up to 60 times faster.  Will give high quality smooth results very close to imagecopyresampled.
	// 4 = Up to 25 times faster.  Almost identical to imagecopyresampled for most images.
	// 5 = No speedup.  Just uses imagecopyresampled, highest quality but no advantage over imagecopyresampled.
	function copyresampled(&$dst_image, $src_image, $dst_x, $dst_y, $src_x, $src_y, $dst_w, $dst_h, $src_w, $src_h, $quality = 3) {
		if(empty($src_image) || empty($dst_image))
			return false;
		if($quality <= 1) {
			$temp = imagecreatetruecolor ($dst_w + 1, $dst_h + 1);
			imagecopyresized ($temp, $src_image, $dst_x, $dst_y, $src_x, $src_y, $dst_w + 1, $dst_h + 1, $src_w, $src_h);
			imagecopyresized ($dst_image, $temp, 0, 0, 0, 0, $dst_w, $dst_h, $dst_w, $dst_h);
			imagedestroy ($temp);
		}elseif($quality < 5 && (($dst_w * $quality) < $src_w || ($dst_h * $quality) < $src_h)) {
			$tmp_w = $dst_w * $quality;
			$tmp_h = $dst_h * $quality;
			$temp = imagecreatetruecolor ($tmp_w + 1, $tmp_h + 1);
			imagecopyresized ($temp, $src_image, $dst_x * $quality, $dst_y * $quality, $src_x, $src_y, $tmp_w + 1, $tmp_h + 1, $src_w, $src_h);
			imagecopyresampled ($dst_image, $temp, 0, 0, 0, 0, $dst_w, $dst_h, $tmp_w, $tmp_h);
			imagedestroy ($temp);
		} else {
			imagecopyresampled ($dst_image, $src_image, $dst_x, $dst_y, $src_x, $src_y, $dst_w, $dst_h, $src_w, $src_h);
		}
		return true;
	}

	// copied from a post by john@mccarthy.net on http://us2.php.net/imagecopy
	// original function name is wave_region
	// modified for horizontal direction, added phase shift
	// amp and period are relative to the original dimension
	function wave_region(&$img, $x, $y, $width, $height, $horizontal = false, $amplitude = 4.5, $period = 30, $shift = 0, $mult = 2) {
		if(!$period) return;

		$width2 = $width * $mult;
		$height2 = $height * $mult;
		$img2 = imagecreatetruecolor($width2, $height2);
		self::copyresampled($img2, $img, 0, 0, $x, $y, $width2, $height2, $width, $height);

		// Wave it
		if($horizontal) {
			for($i = 0; $i < $height2; ++$i) {
			   imagecopy($img2, $img2, $mult*($x + sin($i / $mult / $period) * $amplitude + $shift), $y + $i - 1, $x, $y + $i, $width2, 1);
			}
		} else {
			for($i = 0; $i < $width2; ++$i) {
			   imagecopy($img2, $img2,  $x + $i - 1, $mult*($y + sin(($i / $mult / $period) + $shift) * $amplitude), $x + $i,$y, 1, $height2);
			}
		}
		// Resample it down again
		self::copyresampled($img, $img2, $x, $y, 0, 0, $width, $height, $width2, $height2);
		imagedestroy($img2);
	}


	// draw antialiased line with thickness
	// http://en.wikipedia.org/wiki/Xiaolin_Wu's_line_algorithm
	function line(&$im, $x1, $y1, $x2, $y2, $color, $thickness = 1) {
		$steep = abs($y2 - $y1) > abs($x2 - $x1);
		if($steep) {
			list($x1, $y1) = array($y1, $x1);
			list($x2, $y2) = array($y2, $x2);
		}
		if($x2 < $x1) {
			list($x1, $x2) = array($x2, $x1);
			list($y1, $y2) = array($y2, $y1);
		}
		$dx = $x2 - $x1;
		$dy = $y2 - $y1;

		if(!$dx && !$dy) {
			return false;
		}
		$gradient = $dy / $dx;

		// first endpoint
		$xend = (int)($x1 + 0.5);
		$yend = $y1 + $gradient * ($xend - $x1);
		$xgap = self::wu_rfpart($x1 + 0.5);
		$xpxl1 = $xend;
		$ypxl1 = intval($yend);
		self::wu_plot($im, $xpxl1, $ypxl1, self::wu_rfpart($yend) * $xgap, $color, $steep, $thickness);
		self::wu_plot($im, $xpxl1, $ypxl1 + 1, self::wu_fpart($yend) * $xgap, $color, $steep, $thickness);
		$intery = $yend + $gradient; // first y-intersection for the main loop

		// second endpoint
		$xend = (int)($x2 + 0.5);
		$yend = $y2 + $gradient * ($xend - $x2);
		$xgap = self::wu_fpart($x2 + 0.5);
		$xpxl2 = $xend;
		$ypxl2 = intval($yend);
		self::wu_plot($im, $xpxl2, $ypxl2, self::wu_rfpart($yend) * $xgap, $color, $steep, $thickness);
		self::wu_plot($im, $xpxl2, $ypxl2 + 1, self::wu_fpart($yend) * $xgap, $color, $steep, $thickness);

		for($x = $xpxl1 + 1; $x < $xpxl2; ++$x) {
			self::wu_plot($im, $x, (int)$intery, self::wu_rfpart($intery), $color, $steep, $thickness);
			self::wu_plot($im, $x, (int)$intery + 1, self::wu_fpart($intery), $color, $steep, $thickness);
			$intery += $gradient;
		}
		return true;
	}

	protected function wu_plot(&$im, $x, $y, $c, $color, $swap = false, $thickness = 1) {
		$color = ($color & 0x80FFFFFF) | (((1-$c) * 127) << 24);
		if($swap) {
			list($x, $y) = array($y, $x);
		}
		if($thickness > 1) {
			imagefilledellipse($im, $x, $y, $thickness, $thickness, $color);
		} else {
			imagesetpixel($im, $x, $y, $color);
		}
	}

	protected function wu_fpart($x) {
		return (float)($x - (int)$x);
	}

	protected function wu_rfpart($x) {
		return 1 - self::wu_fpart($x);
	}

	// From Xavier Gouchet @ http://www.xgouchet.fr/bezier.php?language=en
	// removed drawing of points and added thickness
	function bezier4($image, $x1, $y1, $x2, $y2, $x3, $y3, $x4, $y4, $color, $steps = 3, $thickness = 1) {
		if($steps > 1) {
			$inc = 1 / $steps;
			$ox = $x1;
			$oy = $y1;

			for($i = 1; $i < $steps; $i++) {
				// get factors
				$scale = $i*$inc;
				$invscale = 1 - $scale;

				// get J,K,L values
				$jx = ($invscale*$x1) + ($scale*$x2);
				$jy = ($invscale*$y1) + ($scale*$y2);
				$kx = ($invscale*$x2) + ($scale*$x3);
				$ky = ($invscale*$y2) + ($scale*$y3);
				$lx = ($invscale*$x3) + ($scale*$x4);
				$ly = ($invscale*$y3) + ($scale*$y4);

				// get M, N and P values
				$mx = ($invscale*$jx) + ($scale*$kx);
				$my = ($invscale*$jy) + ($scale*$ky);
				$nx = ($invscale*$kx) + ($scale*$lx);
				$ny = ($invscale*$ky) + ($scale*$ly);
				$px = ($invscale*$mx) + ($scale*$nx);
				$py = ($invscale*$my) + ($scale*$ny);

				// draw ''arc''
				$res = self::line($image, $ox, $oy, $px, $py, $color, $thickness);

				// decal o->p
				$ox = $px;
				$oy = $py;
			}
			// finalize curve
			self::line($image, $ox, $oy, $x4, $y4, $color, $thickness);
		} else {
			if($steps == 1) {
				// one step means only one line
				self::line($image, $x1, $y1, $x4, $y4, $color);
			}
		}
		return true;
	}

	// got this function from a post by Alexander Gavazov
	// on http://us3.php.net/manual/en/function.imagettfbbox.php
	function calculate_text_box($size, $angle, $font, $text) {
		$box = imagettfbbox($size, $angle, $font, $text);

		$min_x = min(array($box[0], $box[2], $box[4], $box[6]));
		$max_x = max(array($box[0], $box[2], $box[4], $box[6]));
		$min_y = min(array($box[1], $box[3], $box[5], $box[7]));
		$max_y = max(array($box[1], $box[3], $box[5], $box[7]));

		return array(
			'left' => ($min_x >= -1) ? -abs($min_x + 1) : abs($min_x + 2),
			'top' => abs($min_y),
			'width' => $max_x - $min_x,
			'height' => $max_y - $min_y,
			'box' => $box
		);
	}
}

class Captcha_Generator {
	protected $im;

	public $width = 120;
	public $height = 45;

	// text color, number or array to randomize
	public $color = 0x0; // array(0x9c0032, 0x69c9ff, 0xed00d5, 0x3a60ff, 0xff0328, 0x0017e7, 0xff1ffe, 0x17ccff);

	// background color, number or array to randomize
	public $bgcolor = 0xffffee; // array(0xb6ffc8, 0x69c9ff, 0xf7ffb4, 0xfcd8ff, 0xffe2dd);

	// image format. jpeg, gif, or png
	public $format = 'png';

	// jpeg quality, only if format is jpeg
	public $jpeg_quality = 80;

	// length of random string
	public $string_length = 4;

	// string of characters to pick from. Below is the default with a few characters removed (like lower I and 1)
	public $characters = 'ABCDEFGHJKMNOPQRSTUVWXYZ23456789';

	public $font = 'book.ttf';
	public $font_path = '';
	public $font_size = 14;
	public $font_spacing = -1;

	// number or array of two numbers to randomize
	public $font_angle = array(-10, 10);

	// use the built-in font if FreeType is not available
	public $basic_font = 5;

	// warp the image following a sine wave.
	// Play around with the amplitude and period for best result depending on the image size.
	public $wavify = true;
	// amplitude
	public $wave_amp = 10;
	// period
	public $wave_period = 20;

	// draw a random bezier line across the image
	public $draw_bezier = 1;

	// bezier line thickness
	public $bezier_line_thickness = 1;

	function __construct($options = array()) {
		foreach($options as $k => $v) {
			$this->$k = $v;
		}
	}

	// write to path or stdout
	function output($path = null) {
		if(!$this->im) {
			$this->render_image();
		}
		if(!$path) {
			header("Content-type: image/{$this->format}");
		}
		$fn = "image" . $this->format;

		if($this->format == 'jpeg') {
			$fn($this->im, $path, $this->jpeg_quality);
		} else {
			$fn($this->im, $path);
		}
	}


	// render $text, usually the stored code. Usually not called
	function write($text = null) {
		if(!$text) {
			$text = $this->controller->Session->get('captcha_code');
		}
		$this->im = imagecreatetruecolor($this->width, $this->height);
		imagefill($this->im, 0, 0, is_array($this->bgcolor) ? $this->bgcolor[array_rand($this->bgcolor, 1)]: $this->bgcolor);
		imagesavealpha($this->im, true);
		imagealphablending($this->im, true);

		$text_len = strlen($text);
		$color = is_array($this->color) ? $this->color[array_rand($this->color, 1)]: $this->color;

		if(function_exists('imagettftext')) {
			$letter_spacing = 30;
			$font = $this->font_path . $this->font;

			$write = array();
			$text_width = 0;

			for($i = 0; $i < $text_len; ++$i) {
				$angle = is_array($this->font_angle) ?  mt_rand($this->font_angle[0], $this->font_angle[1]) : $this->font_angle;
				$box = GD_Helper::calculate_text_box($this->font_size, $angle, $font, $text{$i});
				$write[] = array($this->font_size, $angle, $box['width'] + $this->font_spacing, $box['height']);
				$text_width += $box['width'] + $this->font_spacing;
			}
			$x = mt_rand(0, $this->width - $text_width); //($this->width - $text_width) / 2;
			for($i = 0; $i < $text_len; ++$i) {
				list($size, $angle, $width, $height) = $write[$i];
				$y = ($this->height + $height) / 2;
				imagettftext($this->im, $this->font_size, $angle, $x, $y, $color, $font, $text{$i});
				$x += $width;
			}
		} else {
			$font = $this->basic_font;
			$x = floor((imagesx($this->im) - (imagefontwidth($font) * $text_len)) / 2);
			$y = floor((imagesy($this->im) - imagefontheight($font)) / 2);
			imagestring($this->im, $font, $x, $y, $text, $color);
		}


		for($i = 0; $i < $this->draw_bezier; ++$i) {
			$q = $this->width / 4;
			GD_Helper::bezier4($this->im,
				0, mt_rand(0, $this->height),
				mt_rand(0, $q), mt_rand(0, $this->height),
				mt_rand(3*$q, $this->width), mt_rand(0, $this->height),
				$this->width, mt_rand(0, $this->height),
				$color, 25, $this->bezier_line_thickness
			);
		}

		if($this->wavify) {
			GD_Helper::wave_region($this->im,
				0, 0,
				$this->width, $this->height,
				false,
				$this->wave_amp, $this->wave_period, mt_rand(-10, 10), 4
			);
		}
	}

	function destroy() {
		imagedestroy($this->im);
		$this->im = null;
	}

	protected function _get_random_string($len = 5, $p = '') {
		$c = $this->characters;
		$x = strlen($c) - 1;
		for($i = 0; $i < $len; $i++) {
			$p .= $c{mt_rand(0,$x)};
		}
		return $p;
	}
}

?>